home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / langs / xlisp2.1 / xldist02.zoo / sources / xlftab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-09  |  14.2 KB  |  437 lines
  1. /* xlftab.c - xlisp function table */
  2. /*    Copyright (c) 1985, by David Michael Betz
  3.     All Rights Reserved
  4.     Permission is granted for unrestricted non-commercial use    */
  5.  
  6. #include "xlisp.h"
  7.  
  8. /* include system dependant definitions */
  9. #include "osdefs.h"
  10.  
  11. /* SUBR/FSUBR indicator */
  12. #define S    SUBR
  13. #define F    FSUBR
  14.  
  15.  
  16. /* xnotimp - function table entries that are currently not implemented */
  17. LOCAL LVAL xnotimp()
  18. {
  19.     xlfail("function not implemented");
  20.     return NULL;
  21. }
  22.  
  23.  
  24. /* the function table */
  25. FUNDEF funtab[] = {
  26.  
  27.     /* read macro functions */
  28. {    NULL,                S, rmhash        }, /*   0 */
  29. {    NULL,                S, rmquote        }, /*   1 */
  30. {    NULL,                S, rmdquote        }, /*   2 */
  31. {    NULL,                S, rmbquote        }, /*   3 */
  32. {    NULL,                S, rmcomma        }, /*   4 */
  33. {    NULL,                S, rmlpar        }, /*   5 */
  34. {    NULL,                S, rmrpar        }, /*   6 */
  35. {    NULL,                S, rmsemi        }, /*   7 */
  36. {    NULL,                S, xnotimp        }, /*   8 */
  37. {    NULL,                S, xnotimp        }, /*   9 */
  38.  
  39.     /* methods */
  40. {    NULL,                S, clnew        }, /*  10 */
  41. {    NULL,                S, clisnew        }, /*  11 */
  42. {    NULL,                S, clanswer        }, /*  12 */
  43. {    NULL,                S, obisnew        }, /*  13 */
  44. {    NULL,                S, obclass        }, /*  14 */
  45. {    NULL,                S, obshow        }, /*  15 */
  46. #ifdef OBJPRNT
  47. {    NULL,                S, obprin1        }, /*  16 */
  48. #else
  49. {    NULL,                S, xnotimp        }, /*  16 */
  50. #endif
  51. {    NULL,                S, xnotimp        }, /*  17 */
  52. {    NULL,                S, xnotimp        }, /*  18 */
  53. {    NULL,                S, xnotimp        }, /*  19 */
  54.  
  55.     /* evaluator functions */
  56. {    "EVAL",                S, xeval        }, /*  20 */
  57. {    "APPLY",            S, xapply        }, /*  21 */
  58. {    "FUNCALL",            S, xfuncall        }, /*  22 */
  59. {    "QUOTE",            F, xquote        }, /*  23 */
  60. {    "FUNCTION",            F, xfunction    }, /*  24 */
  61. {    "BACKQUOTE",        F, xbquote        }, /*  25 */
  62. {    "LAMBDA",            F, xlambda        }, /*  26 */
  63.  
  64.     /* symbol functions */
  65. {    "SET",                S, xset            }, /*  27 */
  66. {    "SETQ",                F, xsetq        }, /*  28 */
  67. {    "SETF",                F, xsetf        }, /*  29 */
  68. {    "DEFUN",            F, xdefun        }, /*  30 */
  69. {    "DEFMACRO",            F, xdefmacro    }, /*  31 */
  70. {    "GENSYM",            S, xgensym        }, /*  32 */
  71. {    "MAKE-SYMBOL",        S, xmakesymbol    }, /*  33 */
  72. {    "INTERN",             S, xintern        }, /*  34 */
  73. {    "SYMBOL-NAME",        S, xsymname        }, /*  35 */
  74. {    "SYMBOL-VALUE",        S, xsymvalue    }, /*  36 */
  75. {    "SYMBOL-PLIST",        S, xsymplist    }, /*  37 */
  76. {    "GET",                S, xget            }, /*  38 */
  77. {    "PUTPROP",             S, xputprop        }, /*  39 */
  78. {    "REMPROP",            S, xremprop        }, /*  40 */
  79. {    "HASH",                S, xhash        }, /*  41 */
  80.  
  81.     /* array functions */
  82. {    "MAKE-ARRAY",        S, xmkarray        }, /*  42 */
  83. {    "AREF",                S, xaref        }, /*  43 */
  84.             
  85.     /* list functions */
  86. {    "CAR",                S, xcar            }, /*  44 */
  87. {    "CDR",                S, xcdr            }, /*  45 */
  88.             
  89. {    "CAAR",                S, xcaar        }, /*  46 */
  90. {    "CADR",                S, xcadr        }, /*  47 */
  91. {    "CDAR",                S, xcdar        }, /*  48 */
  92. {    "CDDR",                S, xcddr        }, /*  49 */
  93.  
  94. {    "CAAAR",            S, xcaaar        }, /*  50 */
  95. {    "CAADR",            S, xcaadr        }, /*  51 */
  96. {    "CADAR",            S, xcadar        }, /*  52 */
  97. {    "CADDR",            S, xcaddr        }, /*  53 */
  98. {    "CDAAR",            S, xcdaar        }, /*  54 */
  99. {    "CDADR",            S, xcdadr        }, /*  55 */
  100. {    "CDDAR",            S, xcddar        }, /*  56 */
  101. {    "CDDDR",            S, xcdddr        }, /*  57 */
  102.  
  103. {    "CAAAAR",             S, xcaaaar        }, /*  58 */
  104. {    "CAAADR",            S, xcaaadr        }, /*  59 */
  105. {    "CAADAR",            S, xcaadar        }, /*  60 */
  106. {    "CAADDR",            S, xcaaddr        }, /*  61 */
  107. {    "CADAAR",             S, xcadaar        }, /*  62 */
  108. {    "CADADR",            S, xcadadr        }, /*  63 */
  109. {    "CADDAR",            S, xcaddar        }, /*  64 */
  110. {    "CADDDR",            S, xcadddr        }, /*  65 */
  111. {    "CDAAAR",            S, xcdaaar        }, /*  66 */
  112. {    "CDAADR",            S, xcdaadr        }, /*  67 */
  113. {    "CDADAR",            S, xcdadar        }, /*  68 */
  114. {    "CDADDR",            S, xcdaddr        }, /*  69 */
  115. {    "CDDAAR",            S, xcddaar        }, /*  70 */
  116. {    "CDDADR",            S, xcddadr        }, /*  71 */
  117. {    "CDDDAR",            S, xcdddar        }, /*  72 */
  118. {    "CDDDDR",            S, xcddddr        }, /*  73 */
  119.  
  120. {    "CONS",                S, xcons        }, /*  74 */
  121. {    "LIST",                S, xlist        }, /*  75 */
  122. {    "APPEND",            S, xappend        }, /*  76 */
  123. {    "REVERSE",            S, xreverse        }, /*  77 */
  124. {    "LAST",                S, xlast        }, /*  78 */
  125. {    "NTH",                S, xnth            }, /*  79 */
  126. {    "NTHCDR",            S, xnthcdr        }, /*  80 */
  127. {    "MEMBER",            S, xmember        }, /*  81 */
  128. {    "ASSOC",            S, xassoc        }, /*  82 */
  129. {    "SUBST",             S, xsubst        }, /*  83 */
  130. {    "SUBLIS",            S, xsublis        }, /*  84 */
  131. {    "REMOVE",            S, xremove        }, /*  85 */
  132. {    "LENGTH",            S, xlength        }, /*  86 */
  133. {    "MAPC",                S, xmapc        }, /*  87 */
  134. {    "MAPCAR",            S, xmapcar        }, /*  88 */
  135. {    "MAPL",                S, xmapl        }, /*  89 */
  136. {    "MAPLIST",            S, xmaplist        }, /*  90 */
  137.             
  138.     /* destructive list functions */
  139. {    "RPLACA",            S, xrplca        }, /*  91 */
  140. {    "RPLACD",            S, xrplcd        }, /*  92 */
  141. {    "NCONC",            S, xnconc        }, /*  93 */
  142. {    "DELETE",            S, xdelete        }, /*  94 */
  143.  
  144.     /* predicate functions */
  145. {    "ATOM",                S, xatom        }, /*  95 */
  146. {    "SYMBOLP",            S, xsymbolp        }, /*  96 */
  147. {    "NUMBERP",            S, xnumberp        }, /*  97 */
  148. {    "BOUNDP",            S, xboundp         }, /*  98 */
  149. {    "NULL",                S, xnull        }, /*  99 */
  150. {    "LISTP",            S, xlistp        }, /* 100 */
  151. {    "CONSP",            S, xconsp        }, /* 101 */
  152. {    "MINUSP",            S, xminusp         }, /* 102 */
  153. {    "ZEROP",            S, xzerop        }, /* 103 */
  154. {    "PLUSP",            S, xplusp        }, /* 104 */
  155. {    "EVENP",            S, xevenp        }, /* 105 */
  156. {    "ODDP",                S, xoddp        }, /* 106 */
  157. {    "EQ",                S, xeq            }, /* 107 */
  158. {    "EQL",                S, xeql            }, /* 108 */
  159. {    "EQUAL",            S, xequal        }, /* 109 */
  160.  
  161.     /* special forms */
  162. {    "COND",                F, xcond        }, /* 110 */
  163. {    "CASE",                F, xcase        }, /* 111 */
  164. {    "AND",                F, xand            }, /* 112 */
  165. {    "OR",                F, xor            }, /* 113 */
  166. {    "LET",                F, xlet            }, /* 114 */
  167. {    "LET*",                F, xletstar        }, /* 115 */
  168. {    "IF",                F, xif            }, /* 116 */
  169. {    "PROG",                F, xprog        }, /* 117 */
  170. {    "PROG*",            F, xprogstar    }, /* 118 */
  171. {    "PROG1",            F, xprog1        }, /* 119 */
  172. {    "PROG2",            F, xprog2        }, /* 120 */
  173. {    "PROGN",            F, xprogn        }, /* 121 */
  174. {    "GO",                F, xgo            }, /* 122 */
  175. {    "RETURN",            F, xreturn      }, /* 123 */
  176. {    "DO",                F, xdo            }, /* 124 */
  177. {    "DO*",                F, xdostar      }, /* 125 */
  178. {    "DOLIST",            F, xdolist      }, /* 126 */
  179. {    "DOTIMES",            F, xdotimes        }, /* 127 */
  180. {    "CATCH",            F, xcatch        }, /* 128 */
  181. {    "THROW",            F, xthrow        }, /* 129 */
  182.     
  183.     /* debugging and error handling functions */
  184. {    "ERROR",            S, xerror        }, /* 130 */
  185. {    "CERROR",            S, xcerror      }, /* 131 */
  186. {    "BREAK",            S, xbreak        }, /* 132 */
  187. {    "CLEAN-UP",            S, xcleanup        }, /* 133 */
  188. {    "TOP-LEVEL",        S, xtoplevel    }, /* 134 */
  189. {    "CONTINUE",            S, xcontinue    }, /* 135 */
  190. {    "ERRSET",             F, xerrset      }, /* 136 */
  191. {    "BAKTRACE",            S, xbaktrace    }, /* 137 */
  192. {    "EVALHOOK",            S, xevalhook    }, /* 138 */
  193.  
  194.     /* arithmetic functions */
  195. {    "TRUNCATE",            S, xfix            }, /* 139 */
  196. {    "FLOAT",            S, xfloat        }, /* 140 */
  197. {    "+",                S, xadd            }, /* 141 */
  198. {    "-",                S, xsub            }, /* 142 */
  199. {    "*",                S, xmul            }, /* 143 */
  200. {    "/",                S, xdiv            }, /* 144 */
  201. {    "1+",                S, xadd1        }, /* 145 */
  202. {    "1-",                S, xsub1        }, /* 146 */
  203. {    "REM",                S, xrem            }, /* 147 */
  204. {    "MIN",                S, xmin            }, /* 148 */
  205. {    "MAX",                S, xmax            }, /* 149 */
  206. {    "ABS",                S, xabs            }, /* 150 */
  207. {    "SIN",                S, xsin            }, /* 151 */
  208. {    "COS",                S, xcos            }, /* 152 */
  209. {    "TAN",                S, xtan            }, /* 153 */
  210. {    "EXPT",                S, xexpt        }, /* 154 */
  211. {    "EXP",                S, xexp            }, /* 155 */
  212. {    "SQRT",                  S, xsqrt        }, /* 156 */
  213. {    "RANDOM",            S, xrand        }, /* 157 */
  214.             
  215.     /* bitwise logical functions */
  216. {    "LOGAND",            S, xlogand      }, /* 158 */
  217. {    "LOGIOR",            S, xlogior      }, /* 159 */
  218. {    "LOGXOR",            S, xlogxor      }, /* 160 */
  219. {    "LOGNOT",            S, xlognot      }, /* 161 */
  220.  
  221.     /* numeric comparison functions */
  222. {    "<",                S, xlss            }, /* 162 */
  223. {    "<=",                S, xleq            }, /* 163 */
  224. {    "=",                S, xequ            }, /* 164 */
  225. {    "/=",                S, xneq            }, /* 165 */
  226. {    ">=",                S, xgeq            }, /* 166 */
  227. {    ">",                S, xgtr            }, /* 167 */
  228.             
  229.     /* string functions */
  230. #ifdef COMMONLISP
  231. {    "CONCATENATE",        S, xconcatenate }, /* 168 */
  232. #else
  233. {    "STRCAT",            S, xstrcat         }, /* 168 */
  234. #endif
  235. {    "SUBSEQ",            S, xsubseq         }, /* 169 */
  236. {    "STRING",            S, xstring         }, /* 170 */
  237. {    "CHAR",                S, xchar        }, /* 171 */
  238.  
  239.     /* I/O functions */
  240. {    "READ",                S, xread        }, /* 172 */
  241. {    "PRINT",            S, xprint        }, /* 173 */
  242. {    "PRIN1",            S, xprin1        }, /* 174 */
  243. {    "PRINC",            S, xprinc        }, /* 175 */
  244. {    "TERPRI",            S, xterpri         }, /* 176 */
  245. {    "FLATSIZE",            S, xflatsize    }, /* 177 */
  246. {    "FLATC",            S, xflatc        }, /* 178 */
  247.             
  248.     /* file I/O functions */
  249. {    "OPEN",                S, xopen        }, /* 179 */
  250. {    "FORMAT",            S, xformat      }, /* 180 */
  251. {    "CLOSE",            S, xclose        }, /* 181 */
  252. {    "READ-CHAR",        S, xrdchar        }, /* 182 */
  253. {    "PEEK-CHAR",        S, xpkchar        }, /* 183 */
  254. {    "WRITE-CHAR",        S, xwrchar        }, /* 184 */
  255. {    "READ-LINE",        S, xreadline    }, /* 185 */
  256.  
  257.     /* system functions */
  258. {    "LOAD",                S, xload        }, /* 186 */
  259. {    "DRIBBLE",            S, xtranscript    }, /* 187 */
  260.  
  261. /* functions specific to xldmem.c */
  262. {    "GC",                S, xgc            }, /* 188 */
  263. {    "EXPAND",            S, xexpand      }, /* 189 */
  264. {    "ALLOC",            S, xalloc        }, /* 190 */
  265. {    "ROOM",                S, xmem            }, /* 191 */
  266. #ifdef SAVERESTORE
  267. {    "SAVE",                S, xsave        }, /* 192 */
  268. {    "RESTORE",            S, xrestore        }, /* 193 */
  269. #else
  270. {    NULL,                S, xnotimp        }, /* 192 */
  271. {    NULL,                S, xnotimp        }, /* 193 */
  272. #endif
  273. /* end of functions specific to xldmem.c */
  274.  
  275. {    "TYPE-OF",            S, xtype        }, /* 194 */
  276. {    "EXIT",                S, xexit        }, /* 195 */
  277. {    "PEEK",                S, xpeek        }, /* 196 */
  278. {    "POKE",                S, xpoke        }, /* 197 */
  279. {    "ADDRESS-OF",        S, xaddrs        }, /* 198 */
  280.  
  281.     /* new functions and special forms */
  282. {    "VECTOR",            S, xvector      }, /* 199 */
  283. {    "BLOCK",            F, xblock        }, /* 200 */
  284. {    "RETURN-FROM",        F, xrtnfrom        }, /* 201 */
  285. {    "TAGBODY",            F, xtagbody        }, /* 202 */
  286. {    "PSETQ",            F, xpsetq        }, /* 203 */
  287. {    "FLET",                F, xflet        }, /* 204 */
  288. {    "LABELS",            F, xlabels      }, /* 205 */
  289. {    "MACROLET",            F, xmacrolet    }, /* 206 */
  290. {    "UNWIND-PROTECT",    F, xunwindprotect}, /* 207 */
  291. {    "PPRINT",            S, xpp            }, /* 208 */
  292. {    "STRING<",            S, xstrlss         }, /* 209 */
  293. {    "STRING<=",            S, xstrleq         }, /* 210 */
  294. {    "STRING=",            S, xstreql         }, /* 211 */
  295. {    "STRING/=",            S, xstrneq         }, /* 212 */
  296. {    "STRING>=",            S, xstrgeq         }, /* 213 */
  297. {    "STRING>",            S, xstrgtr         }, /* 214 */
  298. {    "STRING-LESSP",        S, xstrilss        }, /* 215 */
  299. {    "STRING-NOT-GREATERP",S,xstrileq    }, /* 216 */
  300. {    "STRING-EQUAL",        S, xstrieql        }, /* 217 */
  301. {    "STRING-NOT-EQUAL",    S, xstrineq        }, /* 218 */
  302. {    "STRING-NOT-LESSP",    S, xstrigeq        }, /* 219 */
  303. {    "STRING-GREATERP",    S, xstrigtr        }, /* 220 */
  304. {    "INTEGERP",            S, xintegerp    }, /* 221 */
  305. {    "FLOATP",            S, xfloatp      }, /* 222 */
  306. {    "STRINGP",            S, xstringp        }, /* 223 */
  307. {    "ARRAYP",            S, xarrayp      }, /* 224 */
  308. {    "STREAMP",            S, xstreamp        }, /* 225 */
  309. {    "OBJECTP",            S, xobjectp        }, /* 226 */
  310. {    "STRING-UPCASE",    S, xupcase         }, /* 227 */
  311. {    "STRING-DOWNCASE",    S, xdowncase    }, /* 228 */
  312. {    "NSTRING-UPCASE",    S, xnupcase        }, /* 229 */
  313. {    "NSTRING-DOWNCASE",    S, xndowncase    }, /* 230 */
  314. {    "STRING-TRIM",        S, xtrim        }, /* 231 */
  315. {    "STRING-LEFT-TRIM",    S, xlefttrim    }, /* 232 */
  316. {    "STRING-RIGHT-TRIM",S, xrighttrim    }, /* 233 */
  317. {    "WHEN",                F, xwhen        }, /* 234 */
  318. {    "UNLESS",            F, xunless      }, /* 235 */
  319. {    "LOOP",                F, xloop        }, /* 236 */
  320. {    "SYMBOL-FUNCTION",    S, xsymfunction    }, /* 237 */
  321. {    "FBOUNDP",            S, xfboundp        }, /* 238 */
  322. {    "SEND",                S, xsend        }, /* 239 */
  323. {    "SEND-SUPER",        S, xsendsuper    }, /* 240 */
  324. {    "PROGV",            F, xprogv        }, /* 241 */
  325. {    "CHARACTERP",        S, xcharp        }, /* 242 */
  326. {    "CHAR-INT",            S, xcharint        }, /* 243 */
  327. {    "INT-CHAR",            S, xintchar        }, /* 244 */
  328. {    "READ-BYTE",        S, xrdbyte         }, /* 245 */
  329. {    "WRITE-BYTE",        S, xwrbyte         }, /* 246 */
  330. {    "MAKE-STRING-INPUT-STREAM",    S, xmkstrinput        }, /* 247 */
  331. {    "MAKE-STRING-OUTPUT-STREAM",S, xmkstroutput        }, /* 248 */
  332. {    "GET-OUTPUT-STREAM-STRING",    S, xgetstroutput    }, /* 249 */
  333. {    "GET-OUTPUT-STREAM-LIST",    S, xgetlstoutput    }, /* 250 */
  334. {    "GCD",                S, xgcd            }, /* 251 */
  335. {    "GET-LAMBDA-EXPRESSION",     S, xgetlambda        }, /* 252 */
  336. {    "MACROEXPAND",        S, xmacroexpand    }, /* 253 */
  337. {    "MACROEXPAND-1",    S, x1macroexpand}, /* 254 */
  338. {    "CHAR<",            S, xchrlss      }, /* 255 */
  339. {    "CHAR<=",            S, xchrleq      }, /* 256 */
  340. {    "CHAR=",            S, xchreql      }, /* 257 */
  341. {    "CHAR/=",            S, xchrneq      }, /* 258 */
  342. {    "CHAR>=",            S, xchrgeq      }, /* 259 */
  343. {    "CHAR>",            S, xchrgtr      }, /* 260 */
  344. {    "CHAR-LESSP",        S, xchrilss        }, /* 261 */
  345. {    "CHAR-NOT-GREATERP",S, xchrileq        }, /* 262 */
  346. {    "CHAR-EQUAL",        S, xchrieql        }, /* 263 */
  347. {    "CHAR-NOT-EQUAL",    S, xchrineq        }, /* 264 */
  348. {    "CHAR-NOT-LESSP",    S, xchrigeq        }, /* 265 */
  349. {    "CHAR-GREATERP",    S, xchrigtr        }, /* 266 */
  350. {    "UPPER-CASE-P",        S, xuppercasep    }, /* 267 */
  351. {    "LOWER-CASE-P",        S, xlowercasep    }, /* 268 */
  352. {    "BOTH-CASE-P",        S, xbothcasep    }, /* 269 */
  353. {    "DIGIT-CHAR-P",        S, xdigitp        }, /* 270 */
  354. {    "ALPHANUMERICP",    S, xalphanumericp}, /* 271 */
  355. {    "CHAR-UPCASE",        S, xchupcase    }, /* 272 */
  356. {    "CHAR-DOWNCASE",    S, xchdowncase    }, /* 273 */
  357. {    "DIGIT-CHAR",        S, xdigitchar    }, /* 274 */
  358. {    "CHAR-CODE",        S, xcharcode    }, /* 275 */
  359. {    "CODE-CHAR",        S, xcodechar    }, /* 276 */
  360. {    "ENDP",                S, xendp        }, /* 277 */
  361. {    "REMOVE-IF",        S, xremif        }, /* 278 */
  362. {    "REMOVE-IF-NOT",    S, xremifnot    }, /* 279 */
  363. {    "DELETE-IF",        S, xdelif        }, /* 280 */
  364. {    "DELETE-IF-NOT",    S, xdelifnot    }, /* 281 */
  365. {    "TRACE",            F, xtrace        }, /* 282 */
  366. {    "UNTRACE",            F, xuntrace        }, /* 283 */
  367. {    "SORT",                S, xsort        }, /* 284 */
  368. #ifdef ADDEDTAA
  369. {    "GENERIC",            S, xgeneric        }, /* 285 */
  370. {    "TIME",                F, xtime        }, /* 286 */
  371. {    "COUNT-IF",            S, xcountif        }, /* 287 */
  372. {    "FIND-IF",            S, xfindif        }, /* 288 */
  373. #else
  374. {    NULL,                S, xnotimp        }, /* 285 */
  375. {    NULL,                S, xnotimp        }, /* 286 */
  376. {    NULL,                S, xnotimp        }, /* 287 */
  377. {    NULL,                S, xnotimp        }, /* 288 */
  378. #endif
  379. /* extra table entries */
  380. #ifdef COMMONLISP
  381. {    "COERCE",            S, xcoerce        }, /* 289 */
  382. {    "ELT",                S, xelt            }, /* 290 */
  383. {    "MAP",                S, xmap            }, /* 291 */
  384. #ifdef ADDEDTAA
  385. {    "POSITION-IF",        S, xpositionif    }, /* 292 */
  386. #else
  387. {    NULL,                S, xnotimp        }, /* 292 */
  388. #endif
  389. {    "SEARCH",            S, xsearch        }, /* 293 */
  390. {    "SOME",                S, xsome        }, /* 294 */
  391. {    "EVERY",            S, xevery        }, /* 295 */
  392. {    "NOTANY",            S, xnotany        }, /* 296 */
  393. {    "NOTEVERY",            S, xnotevery    }, /* 297 */
  394. #else
  395. {    NULL,                S, xnotimp        }, /* 289 */
  396. {    NULL,                S, xnotimp        }, /* 290 */
  397. {    NULL,                S, xnotimp        }, /* 291 */
  398. {    NULL,                S, xnotimp        }, /* 292 */
  399. {    NULL,                S, xnotimp        }, /* 293 */
  400. {    NULL,                S, xnotimp        }, /* 294 */
  401. {    NULL,                S, xnotimp        }, /* 295 */
  402. {    NULL,                S, xnotimp        }, /* 296 */
  403. {    NULL,                S, xnotimp        }, /* 297 */
  404. #endif
  405. #ifdef BETTERIO
  406. {    "FILE-POSITION",    S, xfileposition}, /* 298 */
  407. {    "FILE-LENGTH",        S, xfilelength    }, /* 299 */
  408. #else
  409. {    NULL,                S, xnotimp        }, /* 298 */
  410. {    NULL,                S, xnotimp        }, /* 299 */
  411. #endif
  412. #ifdef STRUCTS
  413. {    "DEFSTRUCT",        F, xdefstruct    }, /* 300 */
  414. {    "%STRUCT-TYPE-P",    S, xstrtypep    }, /* 301 */
  415. {    "%MAKE-STRUCT",        S, xmkstruct    }, /* 302 */
  416. {    "%COPY-STRUCT",        S, xcpystruct    }, /* 303 */
  417. {    "%STRUCT-REF",        S, xstrref        }, /* 304 */
  418. {    "%STRUCT-SET",        S, xstrset        }, /* 305 */
  419. {    "ASIN",                S, xasin        }, /* 306 */
  420. {    "ACOS",                S, xacos        }, /* 307 */
  421. {    "ATAN",                S, xatan        }, /* 308 */
  422. #endif
  423. #ifdef APPLYHOOK
  424. {    "APPLYHOOK",        S, xapplyhook    }, /* 309? */
  425. #endif
  426. #ifdef COMMONLISP
  427. {    "NREVERSE",            S, xnreverse    }, /* 310? */
  428. #endif
  429.  
  430.     /* include system dependant function pointers */
  431. #include "osptrs.h"
  432.  
  433. {0,0,0} /* end of table marker */
  434.  
  435. };            
  436.  
  437.